I would mention a queue instead of a Deque here in the explanation. We aren't really using both the stack and queue aspects of this data structure. Instead we are simply using the deque as a queue.

We don't need to keep a separate count variable, len(self.queue) has a time complexity of O(1).

I think in Java solution of "Approach 2: Double-ended Queue" it would be clearer to call the result of queue.poll() as head (as per javadoc) rather than tail. Just to avoid confusion among those, who are not sure how java Deque does work internally. Minor though.

Isn't the circular queue solution backwards regarding the head and tail? The head represents the front of the queue. When you automatically dequeue you are dequeuing the head. Enqueues occur on the tail.

public double Next(int val) {        
    _count++;
    var head = (_tail + 1) % _size;
    _windowSum = _windowSum - _queue[head] + val;
    _tail = (_tail + 1) % _size;
    _queue[_tail] = val;
    return (double)_windowSum / Math.Min(_size, _count);
}

class MovingAverage {
    private final Queue<Integer> window;
    private final int maxSize;
    private double sum = 0.0;

    public MovingAverage(int maxSize) {
        this.window = new ArrayDeque<>(maxSize + 1);
        this.maxSize = maxSize;
    }
    
    public double next(int val) {
        window.add(val);
        sum += val;
        if (window.size() > maxSize) {
            sum -= window.poll();
        }
        return sum / window.size();
    }
}

IMO, keeping count variable in Approach 2 can lead to integer overflow. Better to use length of self.queue

All the approaches given are broken due to integer overflow. Try having 2147483647 as part of the input. You can keep the mean instead of the sum (windowSum), or keep the sum as a double, but then you can have issues with floating point precision.

Here's a simple approach in Python. It uses a queue (specifically a deque that's limited to queue operations) to store the most-recent numbers in the sliding window. It calculates the sum(queue) / len(queue) at each pass.

This isn't quite as efficient as Approach 2, since it needs to sum the k numbers in the queue during each pass. However, I'd argue that it's shorter and easier to follow.

class MovingAverage:

    def __init__(self, size: int):
        self.size = size
        self.queue = deque()

    def next(self, val: int) -> float:
        if len(self.queue) > self.size - 1:
            self.queue.popleft()
        self.queue.append(val)
        return sum(self.queue) / len(self.queue)

Update: Here's a revised version that's more performant (next is O(1), not O(k)). It's a modification of Approach 2.

class MovingAverage:

    def __init__(self, size: int):
        self.queue = collections.deque()
        self.size = size
        self.total = 0

    def next(self, val: int) -> float:
        self.queue.appendleft(val)
        self.total += val
        if len(self.queue) > self.size:
            removed_val = self.queue.pop()
            self.total -= removed_val
        return self.total / len(self.queue)

another version using partial sum.

class MovingAverage {
public:
vector partialSum;
int windowSize;
int current;
/** Initialize your data structure here. */
MovingAverage(int size) {
windowSize = size;
partialSum.push_back(0);
}

double next(int val) {
    partialSum.push_back(partialSum.back() + val);
    int current = partialSum.size()-1;
    if (current <= windowSize) return partialSum.back() / current;
    else return (partialSum.back() - partialSum[current-windowSize] ) /windowSize ;
}

};

class MovingAverage {
    private Queue<Integer> queue;
    private double sum;
    private int maxSize;
    /** Initialize your data structure here. */
    public MovingAverage(int size) {
        queue = new LinkedList<Integer>();
        sum = 0.0;
        maxSize = size;
    }
    
    public double next(int val) {
        if(queue.size() == maxSize){
            sum-=queue.remove();
        }
        queue.add(val);
        sum += val;
        return sum/queue.size();
    }
}

Queue with linkedlist .